// function greeter(person: string): string {
//     return 'Hello,' + person
// }
// console.log(greeter('TypeScript'));

// greeter(123)


let a:unknown
let value:any = a
let v2:unknown = a



// 非空断言
// 一个新的后缀表达式 ！ 可以用来断言操作对象时非null和undefined类型
const fun = (name: string|null|undefined) => {
    const str:string = name!
}

// 确定赋值断言
// 允许在实例属性和变量声明后面放置一个 ！号
let num!:number
const setNumber = () => num = 7
setNumber()
console.log(num);


// 接口
interface Props {
    a:string,
    b:number,
    c:boolean,
    d?:number, // 可选属性
    readonly e: string, //只读属性
    [f:string]:any // 任意属性
}
let res:Props = {
    a:'1',
    b:2,
    c:true,
    d:1,
    e:'hhhh',
    f:'3'
}

// 接口继承
interface nameProps {
    name: string
}
interface prop extends nameProps {
    age:number
}

const obj1:prop = {
    name:'csc',
    age:18
}

// 函数式接口
interface fun {
    (data:number):number
}

const getNumber:fun = (number:number) => number


// 联合类型
// 可辨识联合类型
// type作为可辨识属性
interface A {
    type:1,
    name: string
}

interface B {
    type:2,
    age:number
}
interface C {
    type:3,
    sex:boolean
}

const getInfo = (data:A | B | C) => {
    if(data.type === 1) {
        // ...
    }
}


// 泛型
const calcArr = <T>(data:T):T[] => {
    let list:T[] = []
    for(let i = 0; i < 3; i++) {
        list.push(data)
    }
    return list
}
const resStr:string[] = calcArr<string>('d')
// eg
function eg <T>(value:T):T{
    return value
}

// 泛型接口
interface D<T> {
    data:T
}
const info1: D<string> = {data: '1'}


// typeof可以实现推出类型
let info = {
    name:'csc',
    age:7,
    sex:true
}

type T1 = typeof info
// type T1 = {
//     name: string;
//     age: number;
//     sex: boolean;
// }